1   /*
2    * Copyright (c) 2005, Oracle and/or its affiliates. All rights reserved.
3    * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4    *
5    * This code is free software; you can redistribute it and/or modify it
6    * under the terms of the GNU General Public License version 2 only, as
7    * published by the Free Software Foundation.
8    *
9    * This code is distributed in the hope that it will be useful, but WITHOUT
10   * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
11   * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
12   * version 2 for more details (a copy is included in the LICENSE file that
13   * accompanied this code).
14   *
15   * You should have received a copy of the GNU General Public License version
16   * 2 along with this work; if not, write to the Free Software Foundation,
17   * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
18   *
19   * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
20   * or visit www.oracle.com if you need additional information or have any
21   * questions.
22   */
23  
24  /*
25   * @test
26   * @bug 5045358
27   * @summary Test that Open MBeans support arrays of primitive types.
28   * @author Luis-Miguel Alventosa
29   * @run clean ArrayTypeTest
30   * @run build ArrayTypeTest
31   * @run main ArrayTypeTest
32   */
33  
34  import java.io.FileInputStream;
35  import java.io.FileOutputStream;
36  import java.io.ObjectInputStream;
37  import java.io.ObjectOutputStream;
38  import javax.management.ObjectName;
39  import javax.management.openmbean.ArrayType;
40  import javax.management.openmbean.OpenDataException;
41  import javax.management.openmbean.SimpleType;
42  
43  public class ArrayTypeTest {
44  
45      private static final String toStringResult[] = {
46          "javax.management.openmbean.ArrayType(name=[[Ljava.lang.String;,dimension=2,elementType=javax.management.openmbean.SimpleType(name=java.lang.String),primitiveArray=false)",
47          "javax.management.openmbean.ArrayType(name=[I,dimension=1,elementType=javax.management.openmbean.SimpleType(name=java.lang.Integer),primitiveArray=true)",
48          "javax.management.openmbean.ArrayType(name=[Ljava.lang.Integer;,dimension=1,elementType=javax.management.openmbean.SimpleType(name=java.lang.Integer),primitiveArray=false)",
49          "javax.management.openmbean.ArrayType(name=[[[[I,dimension=4,elementType=javax.management.openmbean.SimpleType(name=java.lang.Integer),primitiveArray=true)",
50          "javax.management.openmbean.ArrayType(name=[[[[Ljava.lang.Integer;,dimension=4,elementType=javax.management.openmbean.SimpleType(name=java.lang.Integer),primitiveArray=false)",
51          "javax.management.openmbean.ArrayType(name=[Ljava.lang.String;,dimension=1,elementType=javax.management.openmbean.SimpleType(name=java.lang.String),primitiveArray=false)",
52          "OpenDataException",
53          "javax.management.openmbean.ArrayType(name=[Ljava.lang.Integer;,dimension=1,elementType=javax.management.openmbean.SimpleType(name=java.lang.Integer),primitiveArray=false)",
54          "javax.management.openmbean.ArrayType(name=[[Ljava.lang.Integer;,dimension=2,elementType=javax.management.openmbean.SimpleType(name=java.lang.Integer),primitiveArray=false)",
55          "javax.management.openmbean.ArrayType(name=[[I,dimension=2,elementType=javax.management.openmbean.SimpleType(name=java.lang.Integer),primitiveArray=true)",
56          "javax.management.openmbean.ArrayType(name=[[[I,dimension=3,elementType=javax.management.openmbean.SimpleType(name=java.lang.Integer),primitiveArray=true)",
57          "javax.management.openmbean.ArrayType(name=[F,dimension=1,elementType=javax.management.openmbean.SimpleType(name=java.lang.Float),primitiveArray=true)",
58          "javax.management.openmbean.ArrayType(name=[[F,dimension=2,elementType=javax.management.openmbean.SimpleType(name=java.lang.Float),primitiveArray=true)",
59          "javax.management.openmbean.ArrayType(name=[Ljavax.management.ObjectName;,dimension=1,elementType=javax.management.openmbean.SimpleType(name=javax.management.ObjectName),primitiveArray=false)",
60          "javax.management.openmbean.ArrayType(name=[[Ljavax.management.ObjectName;,dimension=2,elementType=javax.management.openmbean.SimpleType(name=javax.management.ObjectName),primitiveArray=false)",
61          "javax.management.openmbean.ArrayType(name=[[[Ljava.lang.String;,dimension=3,elementType=javax.management.openmbean.SimpleType(name=java.lang.String),primitiveArray=false)",
62          "javax.management.openmbean.ArrayType(name=[[[Ljava.lang.String;,dimension=3,elementType=javax.management.openmbean.SimpleType(name=java.lang.String),primitiveArray=false)",
63          "javax.management.openmbean.ArrayType(name=[I,dimension=1,elementType=javax.management.openmbean.SimpleType(name=java.lang.Integer),primitiveArray=true)",
64          "javax.management.openmbean.ArrayType(name=[[Z,dimension=2,elementType=javax.management.openmbean.SimpleType(name=java.lang.Boolean),primitiveArray=true)",
65          "javax.management.openmbean.ArrayType(name=[Ljava.lang.Long;,dimension=1,elementType=javax.management.openmbean.SimpleType(name=java.lang.Long),primitiveArray=false)",
66          "javax.management.openmbean.ArrayType(name=[Ljava.lang.Double;,dimension=1,elementType=javax.management.openmbean.SimpleType(name=java.lang.Double),primitiveArray=false)",
67      };
68  
69      private static int checkResult(int i, ArrayType a) {
70          if (a.toString().equals(toStringResult[i])) {
71              System.out.println("Test passed!");
72              return 0;
73          } else {
74              System.out.println("Test failed!");
75              return 1;
76          }
77      }
78  
79      private static int checkGetters(ArrayType a,
80                                      String className,
81                                      String description,
82                                      String typeName,
83                                      boolean isArray,
84                                      boolean isPrimitiveArray,
85                                      int dimension) {
86          int error = 0;
87          if (a.getClassName().equals(className)) {
88              System.out.println("\tArrayType.getClassName() OK!");
89          } else {
90              System.out.println("\tArrayType.getClassName() KO!");
91              System.out.println("\t\t---> expecting " + className);
92              error++;
93          }
94          if (a.getDescription().equals(description)) {
95              System.out.println("\tArrayType.getDescription() OK!");
96          } else {
97              System.out.println("\tArrayType.getDescription() KO!");
98              System.out.println("\t\t---> expecting " + description);
99              error++;
100         }
101         if (a.getTypeName().equals(typeName)) {
102             System.out.println("\tArrayType.getTypeName() OK!");
103         } else {
104             System.out.println("\tArrayType.getTypeName() KO!");
105             System.out.println("\t\t---> expecting " + typeName);
106             error++;
107         }
108         if (a.isArray() == isArray) {
109             System.out.println("\tArrayType.isArray() OK!");
110         } else {
111             System.out.println("\tArrayType.isArray() KO!");
112             System.out.println("\t\t---> expecting " + isArray);
113             error++;
114         }
115         if (a.isPrimitiveArray() == isPrimitiveArray) {
116             System.out.println("\tArrayType.isPrimitiveArray() OK!");
117         } else {
118             System.out.println("\tArrayType.isPrimitiveArray() KO!");
119             System.out.println("\t\t---> expecting " + isPrimitiveArray);
120             error++;
121         }
122         if (a.getDimension() == dimension) {
123             System.out.println("\tArrayType.getDimension() OK!");
124         } else {
125             System.out.println("\tArrayType.getDimension() KO!");
126             System.out.println("\t\t---> expecting " + dimension);
127             error++;
128         }
129 
130         if (error > 0) {
131             System.out.println("Test failed!");
132             return 1;
133         } else {
134             System.out.println("Test passed!");
135             return 0;
136         }
137     }
138 
139     private static void printArrayType(ArrayType a) {
140         System.out.println("\tArrayType.getClassName() = " + a.getClassName());
141         System.out.println("\tArrayType.getDescription() = " + a.getDescription());
142         System.out.println("\tArrayType.getTypeName() = " + a.getTypeName());
143         System.out.println("\tArrayType.isArray() = " + a.isArray());
144         System.out.println("\tArrayType.isPrimitiveArray() = " + a.isPrimitiveArray());
145         System.out.println("\tArrayType.getDimension() = " + a.getDimension());
146     }
147 
148     public static void main(String[] args) throws Exception {
149 
150         System.out.println("\nTest that Open MBeans support arrays of primitive types.");
151 
152         int index = 0;
153         int error = 0;
154 
155         //
156         // Constructor tests
157         //
158         System.out.println("\n>>> Constructor tests");
159 
160         System.out.println("\nArrayType<String[][]> a1 = new ArrayType<String[][]>(2, SimpleType.STRING)");
161         ArrayType<String[][]> a1 = new ArrayType<String[][]>(2, SimpleType.STRING);
162         printArrayType(a1);
163         error += checkResult(index++, a1);
164 
165         System.out.println("\nArrayType<int[]> a2 = new ArrayType<int[]>(SimpleType.INTEGER, true)");
166         ArrayType<int[]> a2 = new ArrayType<int[]>(SimpleType.INTEGER, true);
167         printArrayType(a2);
168         error += checkResult(index++, a2);
169 
170         System.out.println("\nArrayType<Integer[]> a3 = new ArrayType<Integer[]>(SimpleType.INTEGER, false)");
171         ArrayType<Integer[]> a3 = new ArrayType<Integer[]>(SimpleType.INTEGER, false);
172         printArrayType(a3);
173         error += checkResult(index++, a3);
174 
175         System.out.println("\nArrayType<int[][][][]> a4 = new ArrayType<int[][][][]>(3, a2)");
176         ArrayType<int[][][][]> a4 = new ArrayType<int[][][][]>(3, a2);
177         printArrayType(a4);
178         error += checkResult(index++, a4);
179 
180         System.out.println("\nArrayType<Integer[][][][]> a5 = new ArrayType<Integer[][][][]>(3, a3)");
181         ArrayType<Integer[][][][]> a5 = new ArrayType<Integer[][][][]>(3, a3);
182         printArrayType(a5);
183         error += checkResult(index++, a5);
184 
185         System.out.println("\nArrayType<String[]> a6 = new ArrayType<String[]>(SimpleType.STRING, false)");
186         ArrayType<String[]> a6 = new ArrayType<String[]>(SimpleType.STRING, false);
187         printArrayType(a6);
188         error += checkResult(index++, a6);
189 
190         System.out.println("\nArrayType<String[]> a7 = new ArrayType<String[]>(SimpleType.STRING, true)");
191         index++; // skip this dummy entry in the toStringResult array
192         try {
193             ArrayType<String[]> a7 =
194                 new ArrayType<String[]>(SimpleType.STRING, true);
195             System.out.println("\tDid not get expected OpenDataException!");
196             System.out.println("Test failed!");
197             error++;
198         } catch (OpenDataException e) {
199             System.out.println("\tGot expected OpenDataException: " + e);
200             System.out.println("Test passed!");
201         }
202 
203         //
204         // Factory tests
205         //
206         System.out.println("\n>>> Factory tests");
207 
208         System.out.println("\nArrayType<Integer[]> a8 = ArrayType.getArrayType(SimpleType.INTEGER)");
209         ArrayType<Integer[]> a8 = ArrayType.getArrayType(SimpleType.INTEGER);
210         printArrayType(a8);
211         error += checkResult(index++, a8);
212 
213         System.out.println("\nArrayType<Integer[][]> a9 = ArrayType.getArrayType(a8)");
214         ArrayType<Integer[][]> a9 = ArrayType.getArrayType(a8);
215         printArrayType(a9);
216         error += checkResult(index++, a9);
217 
218         System.out.println("\nArrayType<int[][]> a10 = ArrayType.getPrimitiveArrayType(int[][].class)");
219         ArrayType<int[][]> a10 = ArrayType.getPrimitiveArrayType(int[][].class);
220         printArrayType(a10);
221         error += checkResult(index++, a10);
222 
223         System.out.println("\nArrayType<int[][][]> a11 = ArrayType.getArrayType(a10)");
224         ArrayType<int[][][]> a11 = ArrayType.getArrayType(a10);
225         printArrayType(a11);
226         error += checkResult(index++, a11);
227 
228         System.out.println("\nArrayType<float[]> a12 = ArrayType.getPrimitiveArrayType(float[].class)");
229         ArrayType<float[]> a12 = ArrayType.getPrimitiveArrayType(float[].class);
230         printArrayType(a12);
231         error += checkResult(index++, a12);
232 
233         System.out.println("\nArrayType<float[][]> a13 = ArrayType.getArrayType(a12)");
234         ArrayType<float[][]> a13 = ArrayType.getArrayType(a12);
235         printArrayType(a13);
236         error += checkResult(index++, a13);
237 
238         System.out.println("\nArrayType<ObjectName[]> a14 = ArrayType.getArrayType(SimpleType.OBJECTNAME)");
239         ArrayType<ObjectName[]> a14 = ArrayType.getArrayType(SimpleType.OBJECTNAME);
240         printArrayType(a14);
241         error += checkResult(index++, a14);
242 
243         System.out.println("\nArrayType<ObjectName[][]> a15 = ArrayType.getArrayType(a14)");
244         ArrayType<ObjectName[][]> a15 = ArrayType.getArrayType(a14);
245         printArrayType(a15);
246         error += checkResult(index++, a15);
247 
248         System.out.println("\nArrayType<String[][][]> a16 = new ArrayType<String[][][]>(3, SimpleType.STRING)");
249         ArrayType<String[][][]> a16 = new ArrayType<String[][][]>(3, SimpleType.STRING);
250         printArrayType(a16);
251         error += checkResult(index++, a16);
252 
253         System.out.println("\nArrayType<String[]> a17 = new ArrayType<String[]>(1, SimpleType.STRING)");
254         System.out.println("ArrayType<String[][]> a18 = new ArrayType<String[][]>(1, a17)");
255         System.out.println("ArrayType<String[][][]> a19 = new ArrayType<String[][][]>(1, a18)");
256         ArrayType<String[]> a17 = new ArrayType<String[]>(1, SimpleType.STRING);
257         ArrayType<String[][]> a18 = new ArrayType<String[][]>(1, a17);
258         ArrayType<String[][][]> a19 = new ArrayType<String[][][]>(1, a18);
259         printArrayType(a19);
260         error += checkResult(index++, a19);
261 
262         //
263         // Serialization tests
264         //
265         System.out.println("\n>>> Serialization tests\n");
266 
267         ArrayType<int[]> i1 = ArrayType.getPrimitiveArrayType(int[].class);
268         ArrayType<int[]> i2 = null;
269 
270         ArrayType<boolean[][]> b1 = ArrayType.getPrimitiveArrayType(boolean[][].class);
271         ArrayType<boolean[][]> b2 = null;
272 
273         ArrayType<Long[]> l1 = ArrayType.getArrayType(SimpleType.LONG);
274         ArrayType<Long[]> l2 = null;
275 
276         ArrayType<Double[]> d1 = ArrayType.getArrayType(SimpleType.DOUBLE);
277         ArrayType<Double[]> d2 = null;
278 
279         // serialize the objects
280         try {
281             FileOutputStream fo = new FileOutputStream("serial.tmp");
282             ObjectOutputStream so = new ObjectOutputStream(fo);
283             System.out.println("Serialize ArrayType<int[]> i1 = ArrayType.getPrimitiveArrayType(int[].class)");
284             so.writeObject(i1);
285             System.out.println("Serialize ArrayType<boolean[][]> b1 = ArrayType.getPrimitiveArrayType(boolean[][].class)");
286             so.writeObject(b1);
287             System.out.println("Serialize ArrayType<Long[]> l1 = ArrayType.getArrayType(SimpleType.LONG)");
288             so.writeObject(l1);
289             System.out.println("Serialize ArrayType<Double[]> d1 = ArrayType.getArrayType(SimpleType.DOUBLE)");
290             so.writeObject(d1);
291             so.flush();
292         } catch (Exception e) {
293             System.out.println(e);
294             System.exit(1);
295         }
296 
297         // deserialize the objects
298         try {
299             FileInputStream fi = new FileInputStream("serial.tmp");
300             ObjectInputStream si = new ObjectInputStream(fi);
301             System.out.println("Deserialize ArrayType<int[]> i1 = ArrayType.getPrimitiveArrayType(int[].class)");
302             i2 = (ArrayType<int[]>) si.readObject();
303             System.out.println("Deserialize ArrayType<boolean[][]> b1 = ArrayType.getPrimitiveArrayType(boolean[][].class)");
304             b2 = (ArrayType<boolean[][]>) si.readObject();
305             System.out.println("Deserialize ArrayType<Long[]> l1 = ArrayType.getArrayType(SimpleType.LONG)");
306             l2 = (ArrayType<Long[]>) si.readObject();
307             System.out.println("Deserialize ArrayType<Double[]> d1 = ArrayType.getArrayType(SimpleType.DOUBLE)");
308             d2 = (ArrayType<Double[]>) si.readObject();
309         } catch (Exception e) {
310             System.out.println(e);
311             System.exit(1);
312         }
313 
314         if (i1.toString().equals(toStringResult[index++]) &&
315             i1.toString().equals(i2.toString())) {
316             System.out.println("Test passed for ArrayType<int[]> i1 = ArrayType.getPrimitiveArrayType(int[].class)");
317         } else {
318             System.out.println("Test failed for ArrayType<int[]> i1 = ArrayType.getPrimitiveArrayType(int[].class)");
319             error++;
320         }
321         if (b1.toString().equals(toStringResult[index++]) &&
322             b1.toString().equals(b2.toString())) {
323             System.out.println("Test passed for ArrayType<boolean[][]> b1 = ArrayType.getPrimitiveArrayType(boolean[][].class)");
324         } else {
325             System.out.println("Test failed for ArrayType<boolean[][]> b1 = ArrayType.getPrimitiveArrayType(boolean[][].class)");
326             error++;
327         }
328         if (l1.toString().equals(toStringResult[index++]) &&
329             l1.toString().equals(l2.toString())) {
330             System.out.println("Test passed for ArrayType<Long[]> l1 = ArrayType.getArrayType(SimpleType.LONG)");
331         } else {
332             System.out.println("Test failed for ArrayType<Long[]> l1 = ArrayType.getArrayType(SimpleType.LONG)");
333             error++;
334         }
335         if (d1.toString().equals(toStringResult[index++]) &&
336             d1.toString().equals(d2.toString())) {
337             System.out.println("Test passed for ArrayType<Double[]> d1 = ArrayType.getArrayType(SimpleType.DOUBLE)");
338         } else {
339             System.out.println("Test failed for ArrayType<Double[]> d1 = ArrayType.getArrayType(SimpleType.DOUBLE)");
340             error++;
341         }
342 
343         //
344         // Test getters
345         //
346         System.out.println("\n>>> Getter tests");
347 
348         System.out.println("\nArrayType<Integer[][]> g1 = new ArrayType<Integer[][]>(2, SimpleType.INTEGER)");
349         ArrayType<Integer[][]> g1 = new ArrayType<Integer[][]>(2, SimpleType.INTEGER);
350         printArrayType(g1);
351         error += checkGetters(g1,
352                               "[[Ljava.lang.Integer;",
353                               "2-dimension array of java.lang.Integer",
354                               "[[Ljava.lang.Integer;",
355                               true,
356                               false,
357                               2);
358 
359         System.out.println("\nArrayType<int[][]> g2 = ArrayType.getPrimitiveArrayType(int[][].class)");
360         ArrayType<int[][]> g2 = ArrayType.getPrimitiveArrayType(int[][].class);
361         printArrayType(g2);
362         error += checkGetters(g2,
363                               "[[I",
364                               "2-dimension array of int",
365                               "[[I",
366                               true,
367                               true,
368                               2);
369 
370         if (error > 0) {
371             final String msg = "\nTest FAILED! Got " + error + " error(s)";
372             System.out.println(msg);
373             throw new IllegalArgumentException(msg);
374         } else {
375             System.out.println("\nTest PASSED!");
376         }
377     }
378 }